<?php
/**
 * Redis操作类，支持 Master/Slave 的负载集群
 * @Author: zhanghongchen
 */
namespace library;

class Redis {

    static private $_instance=null;
    // 是否使用 M/S 的读写集群方案
    private $_isUseCluster = false;
    // Slave 句柄标记
    private $_sn = 0;
    // 服务器连接句柄
    private $_linkHandle = array(
        'master' => null, // 只支持一台 Master
        'slave' => array(), // 可以有多台 Slave
    );

    //禁止克隆
    private function __clone(){
        //禁止clone
    }

    //静态调用
    public static function getInstance($config=null){
        if ((self::$_instance instanceof self) === FALSE) {
            self::$_instance = new self($config);
        }
        return self::$_instance;
    }

    /**
     * 构造函数
     * @param $config //配置
     */
    private function __construct($config) {
        if($config === null){
            $config=config('redis');
        }
        $this->_isUseCluster = $config['isUseCluster']; //是否采用 M/S 方案
        $rdconf = $config['rdconf'];
        $this->_connect($rdconf, $config['isMaster']);
        if (isset($rdconf['password']) && !empty($rdconf['password'])) {
            $this->_auth($rdconf['password']);
        }
    }

    /**
     * 连接服务器,注意：这里使用长连接，提高效率，但不会自动关闭
     * @param array $config Redis服务器配置
     * @param boolean $isMaster 当前添加的服务器是否为 Master 服务器
     * @return boolean
     */
    private function _connect($config = array('host' => '127.0.0.1', 'port' => 6379), $isMaster = true) {
        // default port
        if (!isset($config['port'])) {
            $config['port'] = 6379;
        }
        // 设置 Master 连接
        if ($isMaster) {
            $this->_linkHandle['master'] = new \Redis();
            $ret = $this->_linkHandle['master']->pconnect($config['host'], $config['port']);
        } else {
            // 多个 Slave 连接
            $this->_linkHandle['slave'][$this->_sn] = new \Redis();
            $ret = $this->_linkHandle['slave'][$this->_sn]->pconnect($config['host'], $config['port']);
            ++$this->_sn;
        }
        return $ret;
    }

    /**
     * 密码授权
     * @param string $password 密码
     * @return mixed
     */
    private function _auth($password)
    {
        return $this->getRedis()->auth($password);
    }

    /**
     * 关闭连接
     *
     * @param int $flag 关闭选择 0:关闭 Master 1:关闭 Slave 2:关闭所有
     * @return boolean
     */
    public function close($flag = 2) {
        switch ($flag) {
            // 关闭 Master
            case 0:
                $this->getRedis()->close();
                break;
            // 关闭 Slave
            case 1:
                for ($i = 0; $i < $this->_sn; ++$i) {
                    $this->_linkHandle['slave'][$i]->close();
                }
                break;
            // 关闭所有
            case 2:
                $this->getRedis()->close();
                for ($i = 0; $i < $this->_sn; ++$i) {
                    $this->_linkHandle['slave'][$i]->close();
                }
                break;
        }
        return true;
    }

    /**
     * 得到 Redis 原始对象可以有更多的操作
     *
     * @param boolean $isMaster 返回服务器的类型 true:返回Master false:返回Slave
     * @param boolean $slaveOne 返回的Slave选择 true:负载均衡随机返回一个Slave选择 false:返回所有的Slave选择
     * @return \Redis object
     */
    public function getRedis($isMaster = true, $slaveOne = true) {
        // 只返回 Master
        if ($isMaster) {
            return $this->_linkHandle['master'];
        } else {
            return $slaveOne ? $this->_getSlaveRedis() : $this->_linkHandle['slave'];
        }
    }

    /**
     * 写缓存
     * @param string $key 组存KEY
     * @param string $value 缓存值
     * @param int $expire 过期时间， 0:表示无过期时间
     */
    public function set($key, $value, $expire = 0) {
        // 永不超时
        if ($expire == 0) {
            $ret = $this->getRedis()->set($key, $value);
        } else {
            $ret = $this->getRedis()->setex($key, $expire, $value);
        }
        return $ret;
    }

    /**
     * 批量设置key
     * @param array $arr
     * @return mixed
     */
    public function mset($arr){
        return $this->getRedis()->mset($arr);
    }

    /**
     * 批量设置Hash key
     * @param string $key
     * @param array $arr
     * @return mixed
     */
    public function hMset($key, $arr){
        return $this->getRedis()->hMset($key, $arr);
    }

    /**
     * 批量获取Hash key
     * @param string $key
     * @param array $arr
     * @return mixed
     */
    public function hMget($key, $arr){
        return $this->getRedis()->hMGet($key, $arr);
    }

    /**
     * 读缓存
     * @param string $key 缓存KEY,支持一次取多个 $key = array('key1','key2')
     * @return string || boolean 失败返回 false, 成功返回字符串
     */
    public function get($key) {
        // 是否一次取多个值
        $func = is_array($key) ? 'mGet' : 'get';
        // 没有使用M/S
        if (!$this->_isUseCluster) {
            return $this->getRedis()->{$func}($key);
        }
        // 使用了 M/S
        return $this->_getSlaveRedis()->{$func}($key);
    }

    /**
     * 条件形式设置缓存，如果 key 不存时就设置，存在时设置失败
     *
     * @param string $key 缓存KEY
     * @param string $value 缓存值
     * @return boolean
     */
    public function setnx($key, $value) {
        return $this->getRedis()->setnx($key, $value);
    }

    /**
     * 删除缓存
     * @param string || array $key 缓存KEY，支持单个健:"key1" 或多个健:array('key1','key2')
     * @return int 删除的健的数量
     */
    public function remove($key) {
        // $key => "key1" || array('key1','key2')
        return $this->getRedis()->delete($key);
    }

    /**
     * 值加加操作,类似 ++$i ,如果 key 不存在时自动设置为 0 后进行加加操作
     * @param string $key 缓存KEY
     * @param int $default 操作时的默认值
     * @return int　操作后的值
     */
    public function incr($key, $default = 1) {
        if ($default == 1) {
            return $this->getRedis()->incr($key);
        } else {
            return $this->getRedis()->incrBy($key, $default);
        }
    }

    /**
     * 值减减操作,类似 --$i ,如果 key 不存在时自动设置为 0 后进行减减操作
     * @param string $key 缓存KEY
     * @param int $default 操作时的默认值
     * @return int　操作后的值
     */
    public function decr($key, $default = 1) {
        if ($default == 1) {
            return $this->getRedis()->decr($key);
        } else {
            return $this->getRedis()->decrBy($key, $default);
        }
    }

    /**
     * 添空当前数据库
     *
     * @return boolean
     */
    public function clear() {
        return $this->getRedis()->flushDB();
    }

    /* =================== 以下私有方法 =================== */
    /**
     * 随机 HASH 得到 Redis Slave 服务器句柄
     *
     * @return redis object
     */
    private function _getSlaveRedis() {
        // 就一台 Slave 机直接返回
        if ($this->_sn <= 1) {
            return $this->_linkHandle['slave'][0];
        }
        // 随机 Hash 得到 Slave 的句柄
        $hash = $this->_hashId(mt_rand(), $this->_sn);
        return $this->_linkHandle['slave'][$hash];
    }

    /**
     * 根据ID得到 hash 后 0～m-1 之间的值
     *
     * @param string $id
     * @param int $m
     * @return int
     */
    private function _hashId($id, $m = 10) {
        //把字符串K转换为 0～m-1 之间的一个值作为对应记录的散列地址
        $k = md5($id);
        $l = strlen($k);
        $b = bin2hex($k);
        $h = 0;
        for ($i = 0; $i < $l; $i++) {
            //相加模式HASH
            $h += substr($b, $i * 2, 2);
        }
        $hash = ($h * 1) % $m;
        return $hash;
    }

    /*==========================队列操作命令========================*/
    /**
     * 在队列头部插入一个元素
     * @param unknown $key
     * @param unknown $value
     * 返回队列长度
     */
    public function lpush($key, $value) {
        return $this->getRedis()->lpush($key, $value);
    }

    /**
     * 在队列尾部插入一个元素
     * @param unknown $key
     * @param unknown $value
     * 返回队列长度
     */
    public function rPush($key,$value){
        return $this->getRedis()->rPush($key,$value); 
    }

    /**
     * 删除并返回队列中的头元素。
     * @param unknown $key
     */
    public function lpop($key) {
        return $this->getRedis()->lpop($key);
    }

    /**
     * 删除并返回队列中的尾元素
     * @param unknown $key
     */
    public function rPop($key){
        return $this->getRedis()->rPop($key);
    }

    /**
     * 返回队列指定区间的元素
     * @param unknown $key
     * @param unknown $start
     * @param unknown $end
     */
    public function lrange($key, $start, $end) {
        return $this->getRedis()->lrange($key, $start, $end);
    }

    /**
     * 返回队列长度
     * @param unknown $key
     */
    public function lLen($key){
        return $this->getRedis()->lLen($key); 
    }

    /**
     * 返回队列中指定索引的元素
     * @param unknown $key
     * @param unknown $index
     */
    public function lIndex($key,$index){
        return $this->getRedis()->lIndex($key,$index);
    }

    /**
     * 设定队列中指定index的值。
     * @param unknown $key
     * @param unknown $index
     * @param unknown $value
     */
    public function lSet($key,$index,$value){
        return $this->getRedis()->lSet($key,$index,$value);
    }

    /*===========================Hash 操作=========================*/
    /**
     * 设置hash集合操作
     */
    public function hset($name, $key, $value) {
        if (is_array($value)) {
            return $this->getRedis()->hset($name, $key, serialize($value));
        }
        return $this->getRedis()->hset($name, $key, $value);
    }

    public function hkeys($name) {
        return $this->getRedis()->hkeys($name);
    }

    public function hexists($name, $value) {
        return $this->getRedis()->hExists($name,$value);
    }

    /**
     *  获得hash集合操作
     */
    public function hget($name, $key = null) {

        return $this->getRedis()->hget($name,$key);
    }

    /**
     *  删除hash集合操作
     */
    public function hdel($name, $key = null) {
        if ($key) {
            return $this->getRedis()->hdel($name, $key);
        }
        return $this->getRedis()->hdel($name);
    }

    /*==========================事务操作========================*/
    /**
     * 开始一个事务
     * 事务的调用有两种模式Redis::MULTI和Redis::PIPELINE，
     * 默认是Redis::MULTI模式，
     * Redis::PIPELINE管道模式速度更快，但没有任何保证原子性有可能造成数据的丢失
     */
    public function multi($type=\Redis::MULTI) {
        return $this->getRedis()->multi();
    }

    /**
     * 执行事务
     */
    public function exec() {
        return $this->getRedis()->exec();
    }

    /**
     * 回滚一个事务
     */
    public function discard(){
        return $this->getRedis()->discard();
    }

    /**
     * 设置过期
     * @param string $key Key名称
     * @param int $seconds 秒
     * @return mixed
     */
    public function expire($key, $seconds) {
        return $this->getRedis()->expire($key, $seconds);
    }

    /**
     * @desc    : 推入队列
     * @date    : 2017-08-21 12:57:35
     * @author  : lawson.zhang<zhangzhihong@ylb.net>
     * @version : 1.0.0.0
     * @param   : string json $message 队列消息
    */
    public function send($message)
    {
        $messageToArray = json_decode($message, true);
        $events = $messageToArray['body'];
        $queueName = $messageToArray['qname'];

        foreach ($events as $_event) {
            $this->getRedis()->lpush($queueName, json_encode($_event, JSON_UNESCAPED_UNICODE));
        }

        return true;
    }
}